"""
Google Gemini模型适配器
"""

import google.generativeai as genai
import json
from typing import Dict, Any, List, Optional
import logging
import asyncio
from .base_adapter import BaseModelAdapter

logger = logging.getLogger(__name__)


class GeminiAdapter(BaseModelAdapter):
    """Google Gemini模型适配器"""

    def __init__(self, api_key: str, model: str = "gemini-pro"):
        super().__init__(api_key, None, model)
        genai.configure(api_key=self.api_key)
        self.client = genai.GenerativeModel(self.model)

    async def generate_completion(
        self,
        messages: List[Dict[str, str]],
        temperature: float = 0.2,
        max_tokens: int = 4000,
        timeout: float = 300.0,
        **kwargs
    ) -> str:
        """生成文本完成"""
        try:
            # 将消息格式转换为Gemini格式
            prompt = self._convert_messages_to_prompt(messages)

            # 配置生成参数
            generation_config = genai.types.GenerationConfig(
                temperature=temperature,
                max_output_tokens=max_tokens,
                candidate_count=1
            )

            # 在线程池中执行同步调用
            loop = asyncio.get_event_loop()
            response = await loop.run_in_executor(
                None,
                lambda: self.client.generate_content(
                    prompt,
                    generation_config=generation_config
                )
            )

            if not response.text:
                raise Exception("Gemini返回空内容")

            content = response.text.strip()
            logger.info(f"Gemini API调用成功，返回内容长度: {len(content)}")
            return content

        except Exception as e:
            logger.error(f"Gemini API调用失败: {str(e)}")
            raise

    def _convert_messages_to_prompt(self, messages: List[Dict[str, str]]) -> str:
        """将OpenAI格式的消息转换为Gemini提示词"""
        prompt_parts = []
        system_instructions = []
        conversation_parts = []

        for message in messages:
            role = message.get("role", "")
            content = message.get("content", "")

            if role == "system":
                system_instructions.append(content)
            elif role == "user":
                conversation_parts.append(f"用户: {content}")
            elif role == "assistant":
                conversation_parts.append(f"助手: {content}")

        # 构建完整的提示词
        if system_instructions:
            prompt_parts.append("系统指令:")
            prompt_parts.extend(system_instructions)
            prompt_parts.append("")  # 空行分隔

        if conversation_parts:
            prompt_parts.extend(conversation_parts)

        # 如果没有任何内容，添加默认提示
        if not prompt_parts:
            prompt_parts.append("请生成测试用例，返回JSON格式。")

        # 强化JSON格式要求 - 在提示词末尾添加明确的JSON格式要求
        final_prompt = "\n\n".join(prompt_parts)

        # 检查是否已经包含JSON格式要求
        if "json" not in final_prompt.lower():
            final_prompt += "\n\n重要提醒：请严格按照JSON格式返回结果，不要包含任何其他文本。"
        else:
            # 即使已有JSON要求，也要强化
            final_prompt += "\n\n注意：必须返回有效的JSON格式，确保所有字段都正确填写。"

        return final_prompt

    def get_provider_name(self) -> str:
        """获取提供商名称"""
        return "Google Gemini"

    def get_supported_models(self) -> List[str]:
        """获取支持的模型列表"""
        # Gemini适配器支持任意Gemini模型名称
        # 返回常见的模型作为参考，但不限制使用其他Gemini模型
        common_models = [
            # Gemini 1.0系列
            "gemini-pro",
            "gemini-pro-vision",
            # Gemini 1.5系列
            "gemini-1.5-pro",
            "gemini-1.5-flash",
            "gemini-1.5-pro-latest",
            "gemini-1.5-flash-latest",
            # Gemini 2.0系列（未来模型）
            "gemini-2.0-flash",
            "gemini-2.0-pro",
            "gemini-2.0-ultra",
            # 其他规格
            "gemini-ultra",
            "gemini-nano",
            "gemini-nano-2",
            # 可能的未来版本
            "gemini-3.0-pro",
            "gemini-3.0-flash",
            "gemini-exp"
        ]

        # 如果当前模型不在常见列表中，也添加进去（支持未来模型）
        if self.model and self.model not in common_models:
            common_models.append(self.model)
            logger.info(f"添加未知Gemini模型到支持列表: {self.model}")

        return common_models

    def validate_config(self) -> bool:
        """验证配置是否有效"""
        if not self.api_key or self.api_key.strip() == "":
            logger.error("Gemini API密钥未配置")
            return False

        if not self.model or self.model.strip() == "":
            logger.error("Gemini模型名称未配置")
            return False

        # 检查是否为占位符
        placeholder_keys = ["your-gemini-api-key-here", "your-api-key-here"]
        if self.api_key in placeholder_keys:
            logger.error("检测到Gemini API密钥为占位符，请配置真实的API密钥")
            return False

        # 检查API密钥格式（Gemini API密钥通常以AIza开头）
        if not self.api_key.startswith("AIza") and len(self.api_key) < 30:
            logger.warning(f"Gemini API密钥格式可能不正确: {self.api_key[:10]}...")

        return True
